package com.module.ble.widget

import android.content.Context
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.RectF
import android.graphics.Typeface
import android.util.AttributeSet
import android.view.MotionEvent
import android.view.View
import com.common.app.R
import com.common.app.utls.TimeUtils.getHourMinute
import com.common.base.app.extras.otherwise
import com.common.base.app.extras.yes
import com.common.base.utils.ViewUtils
import com.common.base.utils.ViewUtils.dp2px
import com.common.base.utils.ViewUtils.sp2px
import com.module.ble.data.bean.CusChartData

/**
 * 压力柱状图表
 * 作者：sosou
 * 版本：1.0
 * 创建日期：13/6/2025
 *
 * 描述：
 * 压力数据柱状图表组件
 * 特点：
 * 1. X轴：00:00-24:00，每30分钟一个数据点（共48个柱子）
 * 2. X轴标记：00:00, 06, 12, 18, 24:00
 * 3. Y轴：分4个阶段（0-30, 30-60, 60-80, 80-100）
 * 4. 柱子值范围：0-100
 * 5. 支持蓝色（有数据）和灰色（无数据/低数据）两种颜色
 * 6. 右侧Y轴色块和标记文字
 * 7. 柱状图区域背景色
 * 8. 支持触摸交互，显示触摸位置的黑色实线和数据回调
 */
class StressBarChart @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {

    // 触摸回调接口
    interface OnBarTouchListener {
        /**
         * 触摸到柱子时的回调
         * @param barIndex 柱子索引（0-47）
         * @param value 柱子对应的数值（0-100）
         * @param timeLabel 时间标签（如："00:00", "00:30"等）
         */
        fun onBarTouched(barIndex: Int, value: Float, timeLabel: String)

        /**
         * 手指离开图表时的回调
         */
        fun onTouchReleased()

        /**
         * 区间平均值
         */
        fun onIntervalAverageValue(selectType: Int, mValue:Float)
    }

    // 画笔
    private val barPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val linePaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val yAxisBarPaint = Paint(Paint.ANTI_ALIAS_FLAG) // Y轴色块画笔
    private val yAxisTextPaint = Paint(Paint.ANTI_ALIAS_FLAG) // Y轴标记文字画笔
    private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG) // 背景画笔
    private val touchLinePaint = Paint(Paint.ANTI_ALIAS_FLAG) // 触摸实线画笔

    // 矩形区域
    private val rectF = RectF()

    // 数据相关 - 修改为使用CusChartData
    private var dataValues = mutableListOf<CusChartData>()
    private val timeLabels = arrayOf("00:00", "06", "12", "18", "24:00")

    // 触摸相关
    private var touchListener: OnBarTouchListener? = null
    private var isTouching = false
    private var touchedBarIndex = -1
    private var touchLineX = 0f

    // 颜色配置
    private var activeBarColor = ViewUtils.getColor(R.color.c_5282ff) // 蓝色
    private var inactiveBarColor = ViewUtils.getColor(R.color.color_d9d9d9) // 灰色
    private var textColor = ViewUtils.getColor(R.color.c_7f7f7f)
    private var gridLineColor = ViewUtils.getColor(R.color.color_d9d9d9)
    private var chartBackgroundColor = ViewUtils.getColor(R.color.color_FAFAFA) // 柱状图背景色
    private var touchLineColor = ViewUtils.getColor(android.R.color.black) // 触摸实线颜色

    // Y轴色块颜色配置
    private val yAxisStageColors = arrayOf(
        ViewUtils.getColor(R.color.c_bcceff), // 0-30: 浅蓝色
        ViewUtils.getColor(R.color.c_86b1ff), // 30-60: 天蓝色
        ViewUtils.getColor(R.color.c_5282ff), // 60-80: 深蓝色
        ViewUtils.getColor(R.color.c_ff8a06) // 80-100: 橙色
    )

    // Y轴标记文字
    private val yAxisStageLabels = arrayOf("30", "60", "80", "100")

    // 尺寸配置
    private var barSpacing = dp2px(1f)
    private var textSize = sp2px(12f)
    private var chartPaddingTop = dp2px(5f)
    private var chartPaddingBottom = dp2px(30f)

    // Y轴色块相关尺寸
    private var yAxisBarWidth = dp2px(5f) // Y轴色块宽度
    private var yAxisTextSize = sp2px(10f) // Y轴标记文字大小
    private var yAxisTextMargin = dp2px(5f) // 标记文字距离色块的间距

    // Y轴阶段分界线
    private val yAxisStages = floatArrayOf(0f, 30f, 60f, 80f, 100f)

    // 添加selectType属性
    private var selectType: Int = 0

    init {
        // 获取自定义属性
        val typedArray = context.obtainStyledAttributes(attrs, R.styleable.StressBarChart)
        activeBarColor = typedArray.getColor(R.styleable.StressBarChart_stress_activeBarColor, activeBarColor)
        inactiveBarColor = typedArray.getColor(R.styleable.StressBarChart_stress_inactiveBarColor, inactiveBarColor)
        textColor = typedArray.getColor(R.styleable.StressBarChart_stress_textColor, textColor)
        gridLineColor = typedArray.getColor(R.styleable.StressBarChart_stress_gridLineColor, gridLineColor)
        textSize = typedArray.getDimension(R.styleable.StressBarChart_stress_textSize, textSize)
        typedArray.recycle()

        // 初始化画笔
        textPaint.color = textColor
        textPaint.textSize = textSize
        textPaint.textAlign = Paint.Align.CENTER
//        textPaint.typeface = Typeface.DEFAULT_BOLD

        linePaint.color = gridLineColor
        linePaint.strokeWidth = dp2px(1f)

        // 初始化Y轴标记文字画笔
        yAxisTextPaint.color = textColor
        yAxisTextPaint.textSize = yAxisTextSize
        yAxisTextPaint.textAlign = Paint.Align.LEFT

        // 初始化背景画笔
        backgroundPaint.color = chartBackgroundColor
        backgroundPaint.style = Paint.Style.FILL

        // 初始化触摸实线画笔
        touchLinePaint.color = touchLineColor
        touchLinePaint.strokeWidth = dp2px(1f)
        touchLinePaint.style = Paint.Style.STROKE

        // 初始化默认数据（48个空数据点）
        initializeDefaultData()
    }

    /**
     * 初始化默认数据
     */
    private fun initializeDefaultData() {
        dataValues.clear()
//        repeat(48) {
//            dataValues.add(CusChartData(createdTime= 0L, mValue = -1f))
//        }
    }

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        val width = MeasureSpec.getSize(widthMeasureSpec)
        val heightMode = MeasureSpec.getMode(heightMeasureSpec)

        // 计算最小高度
        val minHeight = (chartPaddingTop + chartPaddingBottom + dp2px(200f)).toInt()
        val height = when (heightMode) {
            MeasureSpec.EXACTLY -> MeasureSpec.getSize(heightMeasureSpec)
            else -> minHeight
        }

        setMeasuredDimension(width, height)
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)

        val chartHeight = height - chartPaddingTop - chartPaddingBottom

        // 绘制柱状图背景
        drawChartBackground(canvas, chartHeight)

        // 绘制Y轴网格线
        drawYAxisGrid(canvas, chartHeight)

        // 绘制柱状图
        drawBars(canvas, chartHeight)

        // 绘制触摸实线（在柱状图之后绘制，确保在最上层）
        if (isTouching && touchedBarIndex >= 0) {
            drawTouchLine(canvas, chartHeight)
        }

        // 绘制X轴时间标签
        drawTimeLabels(canvas, chartHeight)

        // 绘制右侧Y轴色块和标记文字
        drawYAxisStageIndicators(canvas, chartHeight)
    }

    /**
     * 绘制柱状图背景
     */
    private fun drawChartBackground(canvas: Canvas, chartHeight: Float) {
        // 计算Y轴色块的位置
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 绘制背景矩形
        rectF.set(
            0f, // 左边界
            chartPaddingTop, // 上边界
            yAxisBarX, // 右边界（到Y轴色块左侧）
            chartPaddingTop + chartHeight // 下边界
        )
        canvas.drawRect(rectF, backgroundPaint)
    }

    /**
     * 绘制Y轴网格线
     */
    private fun drawYAxisGrid(canvas: Canvas, chartHeight: Float) {
        // 计算Y轴色块的位置
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 计算所有barSpacing的总宽度
        val totalSpacingWidth = (dataValues.size - 1) * barSpacing

        // 计算每条柱子的宽度
        val barWidth = (yAxisBarX - totalSpacingWidth) / dataValues.size

        // 柱状图起始位置（左对齐）
        val barsStartX = 0f

        // 网格线右边界：Y轴标记文字的右侧
        val gridLineEndX = yAxisBarX + yAxisBarWidth + yAxisTextMargin + maxTextWidth

        // 创建虚线画笔
        val dashedLinePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
            color = gridLineColor
            strokeWidth = dp2px(1f)
            pathEffect = android.graphics.DashPathEffect(floatArrayOf(dp2px(2f), dp2px(3f)), 0f)
        }

        // 创建加粗实线画笔（用于顶部和底部）
        val boldLinePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
            color = gridLineColor
//            strokeWidth = dp2px(2f) // 加粗线条
            strokeWidth = dp2px(1f)
        }

        // 绘制Y轴网格线
        for (i in yAxisStages.indices) {
            val stage = yAxisStages[i]

            when (i) {
                0 -> {
                    // 底部网格线（0%）- 绘制在柱状图下方
                    val bottomY = chartPaddingTop + chartHeight + dp2px(1f) // 在图表底部下方1dp处
                    canvas.drawLine(
                        barsStartX, // 使用柱状图的实际起始位置
                        bottomY,
                        gridLineEndX, // 延伸到Y轴标记文字右侧
                        bottomY,
                        boldLinePaint
                    )
                }
                yAxisStages.size - 1 -> {
                    // 顶部网格线（100%）- 加粗实线
                    val y = chartPaddingTop + chartHeight * (1 - stage / 100f) - dp2px(1f)
                    canvas.drawLine(
                        barsStartX, // 使用柱状图的实际起始位置
                        y,
                        gridLineEndX, // 延伸到Y轴标记文字右侧
                        y,
                        boldLinePaint
                    )
                }
                else -> {
                    // 中间的网格线（30%, 60%, 80%）- 虚线
                    val y = chartPaddingTop + chartHeight * (1 - stage / 100f)
                    canvas.drawLine(
                        barsStartX,
                        y,
                        yAxisBarX,
                        y,
                        dashedLinePaint
                    )
                }
            }
        }
    }

    /**
     * 绘制柱状图
     */
    private fun drawBars(canvas: Canvas, chartHeight: Float) {
        // 计算Y轴色块的位置
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 计算所有barSpacing的总宽度
        val totalSpacingWidth = (dataValues.size - 1) * barSpacing

        // 计算每条柱子的宽度
        val barWidth = (yAxisBarX - totalSpacingWidth) / dataValues.size

        // 柱状图起始位置（左对齐）
        val startX = 0f

        // 添加背景柱画笔
        val backgroundBarPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
            color = ViewUtils.getColor(R.color.c_c2c5cc) // 浅灰色背景
            style = Paint.Style.FILL
        }

        // 先绘制所有背景柱（连续无间隙）
        var hasBackgroundBar = false
        var backgroundStartX = 0f
        var backgroundEndX = 0f

        for (i in dataValues.indices) {
            if (dataValues[i].selectBg) {
                val left = startX + i * (barWidth + barSpacing)
                val right = left + barWidth

                if (!hasBackgroundBar) {
                    // 开始新的背景柱区域
                    hasBackgroundBar = true
                    backgroundStartX = left
                    backgroundEndX = right
                } else {
                    // 扩展背景柱区域
                    backgroundEndX = right
                }
            } else {
                // 当前柱子不需要背景，绘制之前累积的背景柱
                if (hasBackgroundBar) {
                    val backgroundTop = chartPaddingTop + chartHeight * (1 - 100f / 100f) // 顶部网格线位置
                    val backgroundBottom = chartPaddingTop + chartHeight // 底部网格线位置

                    rectF.set(backgroundStartX, backgroundTop, backgroundEndX, backgroundBottom)
                    canvas.drawRect(rectF, backgroundBarPaint)

                    hasBackgroundBar = false
                }
            }
        }

        // 绘制最后的背景柱（如果有）
        if (hasBackgroundBar) {
            val backgroundTop = chartPaddingTop + chartHeight * (1 - 100f / 100f) // 顶部网格线位置
            val backgroundBottom = chartPaddingTop + chartHeight // 底部网格线位置

            rectF.set(backgroundStartX, backgroundTop, backgroundEndX, backgroundBottom)
            canvas.drawRect(rectF, backgroundBarPaint)
        }

        // 然后绘制数据柱
        for (i in dataValues.indices) {
            var value = dataValues[i].mValue // 使用CusChartData的mValue属性

            // 添加数值范围限制：小于0时默认为0，大于等于100时默认为100
            value = when {
                value < 0f -> 0f
                value >= 100f -> 100f
                else -> value
            }

            val barHeight = chartHeight * (value / 100f)

            // 根据selectType选择颜色逻辑
            barPaint.color = when (selectType) {
                0 -> {
                    // 根据数值范围选择对应的yAxisStageColors颜色
                    when (value) {
                        in 0f..30f -> yAxisStageColors[0]
                        in 31f..60f -> yAxisStageColors[1]
                        in 61f..80f -> yAxisStageColors[2]
                        in 81f..100f -> yAxisStageColors[3]
                        else -> yAxisStageColors[0]
                    }
                }
                1 -> {
                    // 只有00:00至06:00的时间段使用yAxisStageColors[0]，其它为inactiveBarColor
                    if (i in 0..11) when (value) {
                        in 0f..30f -> yAxisStageColors[0]
                        in 31f..60f -> yAxisStageColors[1]
                        in 61f..80f -> yAxisStageColors[2]
                        in 81f..100f -> yAxisStageColors[3]
                        else -> yAxisStageColors[0]
                    } else inactiveBarColor // 0-11对应00:00-05:30
                }
                2 -> {
                    // 只有06:30至12:00的时间段使用yAxisStageColors[1]，其它为inactiveBarColor
                    if (i in 13..23) when (value) {
                        in 0f..30f -> yAxisStageColors[0]
                        in 31f..60f -> yAxisStageColors[1]
                        in 61f..80f -> yAxisStageColors[2]
                        in 81f..100f -> yAxisStageColors[3]
                        else -> yAxisStageColors[0]
                    } else inactiveBarColor // 13-23对应06:30-11:30
                }
                3 -> {
                    // 只有12:30至18:00的时间段使用yAxisStageColors[2]，其它为inactiveBarColor
                    if (i in 25..35) when (value) {
                        in 0f..30f -> yAxisStageColors[0]
                        in 31f..60f -> yAxisStageColors[1]
                        in 61f..80f -> yAxisStageColors[2]
                        in 81f..100f -> yAxisStageColors[3]
                        else -> yAxisStageColors[0]
                    } else inactiveBarColor // 25-35对应12:30-17:30
                }
                4 -> {
                    // 只有18:30至24:00的时间段使用yAxisStageColors[3]，其它为inactiveBarColor
                    if (i in 37..47) when (value) {
                        in 0f..30f -> yAxisStageColors[0]
                        in 31f..60f -> yAxisStageColors[1]
                        in 61f..80f -> yAxisStageColors[2]
                        in 81f..100f -> yAxisStageColors[3]
                        else -> yAxisStageColors[0]
                    } else inactiveBarColor // 37-47对应18:30-23:30
                }
                else -> inactiveBarColor // 默认颜色
            }

            val left = startX + i * (barWidth + barSpacing)
            val top = chartPaddingTop + chartHeight - barHeight
            val right = left + barWidth
            val bottom = chartPaddingTop + chartHeight

            rectF.set(left, top, right, bottom)
            canvas.drawRect(rectF, barPaint)
        }

        if (isTouching) return
        // 计算selectType对应区间的平均值
        val intervalIndices = when (selectType) {
            1 -> 0..11    // 00:00至06:00 (0-11对应00:00-05:30)
            2 -> 13..23   // 06:30至12:00 (13-23对应06:30-11:30)
            3 -> 25..35   // 12:30至18:00 (25-35对应12:30-17:30)
            4 -> 37..47   // 18:30至24:00 (37-47对应18:30-23:30)
            else -> 0 until dataValues.size // selectType为0时计算所有数据
        }

        // 计算指定区间内有效数据的平均值
        val validValues = mutableListOf<Float>()
        for (i in intervalIndices) {
            if (i < dataValues.size) {
                val value = dataValues[i].mValue
                // 只计算有效数据（大于等于0的值）
                if (value > 0.00f) {
                    validValues.add(value)
                }
            }
        }

        // 如果有有效数据，计算平均值并回调
        validValues.isNullOrEmpty().yes {
            touchListener?.onIntervalAverageValue(selectType, -1f)
        }.otherwise {
            val averageValue = validValues.average().toFloat()
            touchListener?.onIntervalAverageValue(selectType, averageValue)
        }
    }

    /**
     * 绘制触摸实线
     */
    private fun drawTouchLine(canvas: Canvas, chartHeight: Float) {
        // 计算Y轴色块的位置
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 计算所有barSpacing的总宽度
        val totalSpacingWidth = (dataValues.size - 1) * barSpacing

        // 计算每条柱子的宽度
        val barWidth = (yAxisBarX - totalSpacingWidth) / dataValues.size

        // 柱状图起始位置（左对齐）
        val startX = 0f

        // 计算触摸的柱子中心X坐标
        val barCenterX = startX + touchedBarIndex * (barWidth + barSpacing) + barWidth / 2

        // 绘制从底部网格线到顶部网格线的黑色实线
        val topY = chartPaddingTop + chartHeight * (1 - 100f / 100f) // 顶部网格线位置
        val bottomY = chartPaddingTop + chartHeight // 底部网格线位置

        canvas.drawLine(barCenterX, topY, barCenterX, bottomY, touchLinePaint)
    }

    /**
     * 绘制X轴时间标签
     */
    private fun drawTimeLabels(canvas: Canvas, chartHeight: Float) {
        // 计算Y轴色块的位置
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 计算所有barSpacing的总宽度
        val totalSpacingWidth = (dataValues.size - 1) * barSpacing

        // 计算每条柱子的宽度
        val barWidth = (yAxisBarX - totalSpacingWidth) / dataValues.size

        // 柱状图起始位置（左对齐）
        val startX = 0f

        // 计算总的柱状图宽度
        val totalBarWidth = dataValues.size * barWidth + totalSpacingWidth

        val labelY = chartPaddingTop + chartHeight + dp2px(20f)

        // 绘制时间标签（每6小时一个，对应12个柱子的间隔）
        for (i in timeLabels.indices) {
            val barIndex = when (i) {
                0 -> 0 // 00:00
                1 -> 12 // 06:00
                2 -> 24 // 12:00
                3 -> 36 // 18:00
                4 -> 47 // 24:00 (最后一个)
                else -> 0
            }

            val labelX = if (i == 0) {
                // 第一个标签（00:00）与第一个柱子的左边对齐
                startX
            } else if (i == timeLabels.size - 1) {
                // 最后一个标签（24:00）位于最右侧
                startX + totalBarWidth
            } else {
                // 其他标签位于对应柱子的中心
                startX + barIndex * (barWidth + barSpacing) + barWidth / 2
            }

            // 第一个标签使用左对齐，其他标签使用居中对齐
            if (i == 0) {
                val originalAlign = textPaint.textAlign
                textPaint.textAlign = Paint.Align.LEFT
                canvas.drawText(timeLabels[i], labelX, labelY, textPaint)
                textPaint.textAlign = originalAlign
            } else {
                canvas.drawText(timeLabels[i], labelX, labelY, textPaint)
            }
        }
    }

    /**
     * 绘制右侧Y轴色块和标记文字
     */
    private fun drawYAxisStageIndicators(canvas: Canvas, chartHeight: Float) {
        // 动态计算最大文字宽度
        val maxTextWidth = calculateMaxYAxisTextWidth()

        // 计算总的指示器宽度
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth

        // Y轴色块的X位置：从控件最右边往左计算
        val yAxisBarX = width - totalIndicatorWidth

        // 绘制四个阶段的色块和标记文字
        for (i in 0 until 4) {
            val stageStart = yAxisStages[i]
            val stageEnd = yAxisStages[i + 1]

            // 计算色块的Y位置和高度
            val stageTopY = chartPaddingTop + chartHeight * (1 - stageEnd / 100f)
            val stageBottomY = chartPaddingTop + chartHeight * (1 - stageStart / 100f)
            val stageHeight = stageBottomY - stageTopY

            // 绘制色块
            yAxisBarPaint.color = yAxisStageColors[i]
            rectF.set(
                yAxisBarX,
                stageTopY,
                yAxisBarX + yAxisBarWidth,
                stageBottomY
            )
            canvas.drawRect(rectF, yAxisBarPaint)

            // 绘制标记文字（在色块右边）
            // 文字Y位置：对应Y轴网格线的下方位置
            val gridLineY = chartPaddingTop + chartHeight * (1 - stageEnd / 100f)
            val textY = gridLineY + yAxisTextSize + dp2px(2f) // 网格线下方2dp处，加上文字高度的用于垂直居中
            val textX = yAxisBarX + yAxisBarWidth + yAxisTextMargin
            canvas.drawText(yAxisStageLabels[i], textX, textY, yAxisTextPaint)
        }
    }

    /**
     * 计算Y轴标记文字的最大宽度
     */
    private fun calculateMaxYAxisTextWidth(): Float {
        var maxTextWidth = 0f
        for (label in yAxisStageLabels) {
            val textWidth = yAxisTextPaint.measureText(label)
            if (textWidth > maxTextWidth) {
                maxTextWidth = textWidth + dp2px(14f)
            }
        }
        return maxTextWidth
    }

    private fun findViewPager2(): androidx.viewpager2.widget.ViewPager2? {
        var parent = parent
        while (parent != null) {
            if (parent is androidx.viewpager2.widget.ViewPager2) {
                return parent
            }
            parent = parent.parent
        }
        return null
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        if (dataValues.isNullOrEmpty()) return true//无数据是直接透传触摸
        val viewPager2 = findViewPager2()

        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                if (dataValues.isNullOrEmpty()) return true//无数据是直接透传触摸

                if (isTouchInChartArea(event.x, event.y)) {
                    // 直接禁用ViewPager2的用户输入
                    viewPager2?.isUserInputEnabled = false
                    parent?.requestDisallowInterceptTouchEvent(true)
                    handleTouch(event.x, event.y)
                    return true
                }
            }
            MotionEvent.ACTION_MOVE -> {
                if (isTouching && touchedBarIndex >= 0) {
                    handleTouch(event.x, event.y)
                    return true
                }
            }
            MotionEvent.ACTION_UP,
            MotionEvent.ACTION_CANCEL -> {
                // 恢复ViewPager2的用户输入
                viewPager2?.isUserInputEnabled = true
                parent?.requestDisallowInterceptTouchEvent(false)
                handleTouchRelease()
                return true
            }
        }
        return super.onTouchEvent(event)
    }

    /**
     * 检查触摸点是否在图表区域内
     */
    private fun isTouchInChartArea(touchX: Float, touchY: Float): Boolean {
        val chartHeight = height - chartPaddingTop - chartPaddingBottom

        // 检查Y轴范围
        if (touchY < chartPaddingTop || touchY > chartPaddingTop + chartHeight) {
            return false
        }

        // 计算图表区域的X轴范围
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 检查X轴范围
        return touchX >= 0 && touchX <= yAxisBarX
    }

    /**
     * 处理触摸事件
     */
    private fun handleTouch(touchX: Float, touchY: Float) {
        val chartHeight = height - chartPaddingTop - chartPaddingBottom

        // 检查触摸点是否在图表区域内
        if (touchY < chartPaddingTop || touchY > chartPaddingTop + chartHeight) {
            return
        }

        // 计算Y轴色块的位置
        val maxTextWidth = calculateMaxYAxisTextWidth()
        val totalIndicatorWidth = yAxisBarWidth + yAxisTextMargin + maxTextWidth
        val yAxisBarX = width - totalIndicatorWidth

        // 检查触摸点是否在柱状图区域内
        if (touchX < 0 || touchX > yAxisBarX) {
            return
        }

        // 计算所有barSpacing的总宽度
        val totalSpacingWidth = (dataValues.size - 1) * barSpacing

        // 计算每条柱子的宽度
        val barWidth = (yAxisBarX - totalSpacingWidth) / dataValues.size

        // 柱状图起始位置（左对齐）
        val startX = 0f

        // 计算触摸的柱子索引
        val barIndex = ((touchX - startX) / (barWidth + barSpacing)).toInt()

        if (barIndex >= 0 && barIndex < dataValues.size) {
            isTouching = true
            touchedBarIndex = barIndex
            touchLineX = startX + barIndex * (barWidth + barSpacing) + barWidth / 2

//            // 生成时间标签
//            val hours = barIndex / 2
//            val minutes = (barIndex % 2) * 30
//            val timeLabel = String.format("%02d:%02d", hours, minutes)

            // 触发回调
            touchListener?.onBarTouched(barIndex, dataValues[barIndex].mValue, "${getHourMinute(dataValues[barIndex].createdTime)}-${getHourMinute(dataValues[barIndex].endTime)}")

            invalidate()
        }
    }

    /**
     * 处理触摸释放事件
     */
    private fun handleTouchRelease() {
        isTouching = false
        touchedBarIndex = -1
        touchListener?.onTouchReleased()
        invalidate()
    }

    /**
     * 设置数据 - 修改为接受CusChartData列表
     */
    fun setData(values: List<CusChartData>) {
        dataValues.clear()
        dataValues.addAll(values)
        // 确保数据长度为48
        while (dataValues.size < 48) {
            dataValues.add(CusChartData(0L, 0f))
        }
        if (dataValues.size > 48) {
            dataValues = dataValues.take(48).toMutableList()
        }
        invalidate()
    }

    /**
     * 设置单个数据点 - 修改为设置mValue
     */
    fun setDataPoint(timeIndex: Int, value: Float) {
        if (timeIndex >= 0 && timeIndex < dataValues.size) {
            dataValues[timeIndex].mValue = value.coerceIn(0f, 100f)
            invalidate()
        }
    }

    /**
     * 获取数据
     */
    fun getData(): List<CusChartData> {
        return dataValues.toList()
    }

    /**
     * 获取指定时间索引的数据值
     */
    fun getDataValue(timeIndex: Int): Float {
        return if (timeIndex >= 0 && timeIndex < dataValues.size) {
            dataValues[timeIndex].mValue
        } else {
            0f
        }
    }

    /**
     * 清空数据
     */
    fun clearData() {
        initializeDefaultData()
        invalidate()
    }

    /**
     * 设置触摸监听器
     */
    fun setOnBarTouchListener(listener: OnBarTouchListener?) {
        touchListener = listener
    }

    /**
     * 获取时间标签
     */
    fun getTimeLabel(barIndex: Int): String {
        if (barIndex < 0 || barIndex >= 48) return ""
        val hours = barIndex / 2
        val minutes = (barIndex % 2) * 30
        return String.format("%02d:%02d", hours, minutes)
    }

    /**
     * 设置选择类型
     * @param type 0:根据数值范围选择颜色 1:00:00-06:00高亮 2:06:30-12:00高亮 3:12:30-18:00高亮 4:18:30-24:00高亮
     */
    fun setSelectType(type: Int) {
        selectType = type
        invalidate() // 重新绘制
    }

    /**
     * 获取当前选择类型
     */
    fun getSelectType(): Int {
        return selectType
    }
}